////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2017-2018 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  camxchinodewrapper.h
/// @brief Chi node wrapper class declarations
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef CAMXCHINODEWRAPPER_H
#define CAMXCHINODEWRAPPER_H

#include "camxchi.h"
#include "camxdefs.h"
#include "camxmem.h"
#include "camxnode.h"
#include "camxtypes.h"
#include "chinode.h"
#include "camxncssensor.h"
#include "camxncsservice.h"

CAMX_NAMESPACE_BEGIN

struct ChiFence;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Class that implements the Chi node wrapper class
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class ChiNodeWrapper final : public Node
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Create
    ///
    /// @brief  Static method to create ChiNodeWrapper Object.
    ///
    /// @param  pCreateInputData  Node create input data
    /// @param  pCreateOutputData Node create output data
    ///
    /// @return Pointer to the concrete ChiNodeWrapper object
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static ChiNodeWrapper* Create(
        const NodeCreateInputData*  pCreateInputData,
        NodeCreateOutputData*       pCreateOutputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// SetupNCSLink
    ///
    /// @brief  Setup an NCS link
    ///
    /// @param  pSensorConfig pointer to the sensor config structure
    ///
    /// @return Pointer to NCS Sensor object
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static NCSSensor* SetupNCSLink(
        NCSSensorConfig* pSensorConfig);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// DestroyNCSLink
    ///
    /// @brief  Destroy NCS link
    ///
    /// @param  pSensor pointer to the sensor handle
    ///
    /// @return CamxResult
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CamxResult DestroyNCSLink(
        VOID* pSensor);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FNGetMetadata
    ///
    /// @brief  The implemenation for PFNNODEGETMETADATA defined in chinode.h
    ///
    /// @param  pMetadataInfo   Pointer to a structure that defines the list of metadata information requested by the node.
    ///
    /// @return CDKResultSuccess if success or appropriate error code.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CDKResult FNGetMetadata(
        CHIMETADATAINFO* pMetadataInfo);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FNCacheOps
    ///
    /// @brief  The implemenation for PFNCACHEOPS defined in chinode.h
    ///
    /// @param  hChiBuffer   Chi buffer handle
    /// @param  invalidata   invalidate cache
    /// @param  clean        clean cache
    ///
    /// @return CDKResultSuccess if success or appropriate error code.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CDKResult FNCacheOps(
        CHINODEBUFFERHANDLE hChiBuffer,
        BOOL                invalidata,
        BOOL                clean);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FNSetMetadata
    ///
    /// @brief  The implemenation for PFNNODESETMETADATA defined in chinode.h
    ///
    /// @param  pMetadataInfo Pointer to a structure that defines the list of metadata information published by the node.
    ///
    /// @return CDKResultSuccess if success or appropriate error code.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CDKResult FNSetMetadata(
        CHIMETADATAINFO* pMetadataInfo);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FNGetVendorTagBase
    ///
    /// @brief  The implemenation for PFNNODEGETVENDORTAGBASE defined in chinode.h
    ///
    /// @param  pVendorTagBaseInfo  Pointer to a structure that defines the run-time Chi assigned vendor tag base.
    ///
    /// @return CDKResultSuccess if success or appropriate error code.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CDKResult FNGetVendorTagBase(
        CHIVENDORTAGBASEINFO* pVendorTagBaseInfo);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FNGetTuningmanager
    ///
    /// @brief  The implementation for PFNNODEGETTUNINGMANAGER defined in chinode.h
    ///
    /// @param  hChiSession Chi driver handle that node can use to callback into Chi
    ///
    /// @return Handle to the tuning manager.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static VOID* FNGetTuningmanager(
        CHIHANDLE hChiSession);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FNProcRequestDone
    ///
    /// @brief  The implemenation for PFNCHINODEPROCREQUESTDONE defined in chinode.h
    ///
    /// @param  pInfo   Pointer to the structure containing information about the request.
    ///
    /// @return CDKResultSuccess if success or appropriate error code.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CDKResult FNProcRequestDone(
        CHINODEPROCESSREQUESTDONEINFO* pInfo);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FNProcMetadataDone
    ///
    /// @brief  The implemenation for PFNCHINODEPROCMETADATADONE defined in chinode.h
    ///
    /// @param  pInfo   Pointer to the structure containing information about the request.
    ///
    /// @return CDKResultSuccess if success or appropriate error code.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CDKResult FNProcMetadataDone(
        CHINODEPROCESSMETADATADONEINFO* pInfo);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FNCreateFence
    ///
    /// @brief  The implemenation for PFNCHINODECREATEFENCE defined in chinode.h
    ///
    /// @param  hChiSession Chi driver handle that node can use to callback into Chi
    /// @param  pInfo       Pointer to the structure containing information about the fence.
    /// @param  phChiFence  Pointer to Chi fence handle to be filled.
    ///
    /// @return CDKResultSuccess if success or appropriate error code.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CDKResult FNCreateFence(
        CHIHANDLE               hChiSession,
        CHIFENCECREATEPARAMS*   pInfo,
        CHIFENCEHANDLE*         phChiFence);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FNReleaseFence
    ///
    /// @brief  The implemenation for PFNCHINODERELEASEFENCE defined in chinode.h
    ///
    /// @param  hChiSession Chi driver handle that node can use to callback into Chi
    /// @param  hChiFence   Handle to Chi fence to be released
    ///
    /// @return CDKResultSuccess if success or appropriate error code.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CDKResult FNReleaseFence(
        CHIHANDLE       hChiSession,
        CHIFENCEHANDLE  hChiFence);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FNGetDataSource
    ///
    /// @brief  The implemenation for PFNGETDATASOURCE defined in chinode.h
    ///
    /// @param  hChiSession        Chi session hadle
    /// @param  phDataSourceHandle Data source handle
    /// @param  pDataSourceConfig  Data source config
    ///
    /// @return CDKResultSuccess if success or appropriate error code.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CDKResult FNGetDataSource(
        CHIHANDLE            hChiSession,
        CHIDATASOURCE*       phDataSourceHandle,
        CHIDATASOURCECONFIG* pDataSourceConfig);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FNGetData
    ///
    /// @brief  The implemenation for PFNGETDATA defined in chinode.h
    ///
    /// @param  hChiSession       Chi session handle
    /// @param  hDataSourceHandle Data source handle
    /// @param  pDataRequest      Data request payload
    /// @param  pSize             Pointer to be filled in with data size
    ///
    /// @return Pointer to the data
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static VOID* FNGetData(
        CHIHANDLE            hChiSession,
        CHIDATASOURCEHANDLE  hDataSourceHandle,
        CHIDATAREQUEST*      pDataRequest,
        UINT*                pSize);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FNPutData
    ///
    /// @brief  The implemenation for PFNPUTDATA defined in chinode.h
    ///
    /// @param  hChiSession       Chi session handle
    /// @param  hDataSourceHandle Data source handle
    /// @param  hData             Data handle
    ///
    /// @return CamxResultSuccess if success
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CDKResult FNPutData(
        CHIHANDLE            hChiSession,
        CHIDATASOURCEHANDLE  hDataSourceHandle,
        CHIDATAHANDLE        hData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FNGetDataNCS
    ///
    /// @brief  API to get NCS data
    ///
    /// @param  hChiSession       Chi session handle
    /// @param  hDataSourceHandle Data source handle
    /// @param  pDataRequest      Data request handle
    /// @param  pSize             Size of the data
    ///
    /// @return Pointer to the data
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static VOID* FNGetDataNCS(
        CHIHANDLE            hChiSession,
        CHIDATASOURCEHANDLE  hDataSourceHandle,
        CHIDATAREQUEST*      pDataRequest,
        UINT*                pSize);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FNPutDataSource
    ///
    /// @brief  The implemenation for PFNGETDATA defined in chinode.h
    ///
    /// @param  hChiSession        Chi Session handle
    /// @param  hDataSourceHandle  Data source handle
    ///
    /// @return CDKResultSuccess if success or appropriate error code.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CDKResult FNPutDataSource(
        CHIHANDLE           hChiSession,
        CHIDATASOURCEHANDLE hDataSourceHandle);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FNWaitFenceAsync
    ///
    /// @brief  The implemenation for PFNCHINODEWAITFENCEASYNC defined in chinode.h
    ///
    /// @param  hChiSession Chi driver handle that node can use to callback into Chi
    /// @param  pCallbackFn Callback function
    /// @param  hChiFence   Handle to Chi fence to be released
    /// @param  pData       User data pointer
    ///
    /// @return CDKResultSuccess if success or appropriate error code.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CDKResult FNWaitFenceAsync(
        CHIHANDLE           hChiSession,
        PFNCHIFENCECALLBACK pCallbackFn,
        CHIFENCEHANDLE      hChiFence,
        VOID*               pData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FNSignalFence
    ///
    /// @brief  The implemenation for PFNCHINODESIGNALFENCE defined in chinode.h
    ///
    /// @param  hChiSession  Chi driver handle that node can use to callback into Chi
    /// @param  hChiFence    Handle to Chi fence to be released
    /// @param  statusResult Fence signalled status result
    ///
    /// @return CDKResultSuccess if success or appropriate error code.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CDKResult FNSignalFence(
        CHIHANDLE           hChiSession,
        CHIFENCEHANDLE      hChiFence,
        CDKResult           statusResult);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FNGetFenceStatus
    ///
    /// @brief  The implemenation for PFNGETFENCESTATUS defined in chinode.h
    ///
    /// @param  hChiSession Chi driver handle that node can use to callback into Chi
    /// @param  hChiFence   Handle to Chi fence to be queried for status
    /// @param  pResult     Pointer to the CDKResult pointer to be filled with fence status
    ///
    /// @return CDKResultSuccess if success or appropriate error code.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CDKResult FNGetFenceStatus(
        CHIHANDLE               hChiSession,
        CHIFENCEHANDLE          hChiFence,
        CDKResult*              pResult);

protected:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ProcessingNodeFinalizeInitialization
    ///
    /// @brief  Method to finalize the initialization of the node in the pipeline
    ///
    /// @param  pFinalizeInitializationData Finalize data
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult ProcessingNodeFinalizeInitialization(
        FinalizeInitializationData* pFinalizeInitializationData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ProcessingNodeInitialize
    ///
    /// @brief  Initialize the sw processing object
    ///
    /// @param  pCreateInputData  Node create input data
    /// @param  pCreateOutputData Node create output data
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult ProcessingNodeInitialize(
        const NodeCreateInputData*  pCreateInputData,
        NodeCreateOutputData*       pCreateOutputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ProcessingNodeFinalizeInputRequirement
    ///
    /// @brief  Implemented by derived nodes to determine its input buffer requirement based on all the output buffer
    ///         requirements
    ///
    /// @param  pBufferNegotiationData  Negotiation data for all output ports of a node
    ///
    /// @return Success if the negotiation was successful, Failure otherwise
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult ProcessingNodeFinalizeInputRequirement(
        BufferNegotiationData* pBufferNegotiationData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FinalizeBufferProperties
    ///
    /// @brief  Finalize the buffer properties of each output port
    ///
    /// @param  pBufferNegotiationData Buffer negotiation data
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual VOID FinalizeBufferProperties(
        BufferNegotiationData* pBufferNegotiationData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PostPipelineCreate
    ///
    /// @brief  virtual method to be called at NotifyTopologyCreated time; node should take care of updates and initialize
    ///         blocks that has dependency on other nodes in the topology at this time.
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult PostPipelineCreate();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ExecuteProcessRequest
    ///
    /// @brief  Pure virtual method to trigger process request for the stats processing node object.
    ///
    /// @param  pExecuteProcessRequestData Process request data
    ///
    /// @return CamxResultSuccess if successful and 0 dependencies, dependency information otherwise
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult ExecuteProcessRequest(
        ExecuteProcessRequestData* pExecuteProcessRequestData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ChiFenceCallback
    ///
    /// @brief  Chi fence callback
    ///
    /// @param  hChiFence   Handle to Chi fence this callback is called for
    /// @param  pUserData   User data provided when waiting on the fence
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static VOID ChiFenceCallback(
        CHIFENCEHANDLE  hChiFence,
        VOID*           pUserData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ChiFenceDependencyCallback
    ///
    /// @brief  Chi fence callback for fence dependency
    ///
    /// @param  hChiFence   Handle to Chi fence this callback is called for
    /// @param  pUserData   User data provided when waiting on the fence
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static VOID ChiFenceDependencyCallback(
        CHIFENCEHANDLE  hChiFence,
        VOID*           pUserData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// OnStreamOn
    ///
    /// @brief  Streamon command
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult OnStreamOn();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// OnStreamOff
    ///
    /// @brief  Streamoff command
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult OnStreamOff();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ChiNodeWrapper
    ///
    /// @brief  Constructor
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ChiNodeWrapper();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ~ChiNodeWrapper
    ///
    /// @brief  Destructor
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ~ChiNodeWrapper();

private:
    ChiNodeWrapper(const ChiNodeWrapper&) = delete;                                       ///< Disallow the copy constructor
    ChiNodeWrapper& operator=(const ChiNodeWrapper&) = delete;                            ///< Disallow assignment operator

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetMetadata
    ///
    /// @brief  Gets a list of metadata information based on metadata tags.
    ///         The tag can be an Android tag or a vendor tag. If the metadata information associated with the tag is not
    ///         published, Chi returns those tags as unpublished when this function returns. The node can add them in the
    ///         dependency reporting during ChiNodeProcRequest().
    ///
    /// @param  pMetadataInfo   Pointer to a structure that defines the list of metadata information requested by the node.
    ///
    /// @return CDKResultSuccess if success or appropriate error code.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CDKResult GetMetadata(
        CHIMETADATAINFO* pMetadataInfo);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// SetMetadata
    ///
    /// @brief  Sets a list of metadata information based on metadata tags.
    ///
    ///         The tag can be an Android tag or a vendor tag. When published, Chi driver will notify all other nodes that
    ///         reported these tags as dependencies.
    ///
    /// @param  pMetadataInfo Pointer to a structure that defines the list of metadata information published by the node.
    ///
    /// @return CDKResultSuccess if success or appropriate error code.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CDKResult SetMetadata(
        CHIMETADATAINFO* pMetadataInfo);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetVendorTagBase
    ///
    /// @brief  Get the base of vendor tags of other nodes.
    ///
    ///         The tag can be from nodes including the Chi default node or other third-party custom nodes on which this node is
    ///         dependent for request processing. The node uses this base and the actual tag offset to derive the
    ///         tag ID(= base + offset) to report the dependencies.
    ///
    /// @param  pVendorTagBaseInfo  Pointer to a structure that defines the run-time Chi assigned vendor tag base.
    ///
    /// @return CDKResultSuccess if success or appropriate error code.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CDKResult GetVendorTagBase(
        CHIVENDORTAGBASEINFO* pVendorTagBaseInfo);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ProcRequestDone
    ///
    /// @brief  Reports the status of request processing.
    ///
    ///         The node calls this function into Chi driver to report the status as success or failure. The fences that are
    ///         associated with the request are signaled accordingly by Chi for this request.
    ///
    /// @param  pInfo   Pointer to the structure containing information about the request.
    ///
    /// @return CDKResultSuccess if success or appropriate error code.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CDKResult ProcRequestDone(
        CHINODEPROCESSREQUESTDONEINFO* pInfo);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ProcMetadataDone
    ///
    /// @brief  Reports the status of processing metadata.
    ///
    ///         The node calls this function into Chi driver to report the status as success or failure of metadata
    ///
    /// @param  pInfo   Pointer to the structure containing information about the request.
    ///
    /// @return CDKResultSuccess if success or appropriate error code.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CDKResult ProcMetadataDone(
        CHINODEPROCESSMETADATADONEINFO* pInfo);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CreateFence
    ///
    /// @brief  Creates a Chi fence give the input parameters.
    ///
    /// @param  pInfo       Pointer to the structure containing information about the fence.
    /// @param  phChiFence  Pointer to Chi fence handle to be filled.
    ///
    /// @return CDKResultSuccess if success or appropriate error code.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CDKResult CreateFence(
        CHIFENCECREATEPARAMS*   pInfo,
        CHIFENCEHANDLE*         phChiFence);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ReleaseFence
    ///
    /// @brief  Releases a Chi fence.
    ///
    /// @param  hChiFence   Handle to Chi fence to be released
    ///
    /// @return CDKResultSuccess if success or appropriate error code.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CDKResult ReleaseFence(
        CHIFENCEHANDLE  hChiFence);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// AllocateChiBufferHandlePool
    ///
    /// @brief  Allocate the pool for CHIBUFFERHANDLE
    ///
    /// @param  size    The size of CHIBUFFERHANDLE pool
    ///
    /// @return CamResultSuccess on success
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CHINODEBUFFERHANDLE* AllocateChiBufferHandlePool(
        INT32 size);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ReleaseChiBufferHandlePool
    ///
    /// @brief  Free the allocated pool for CHIBUFFERHANDLE
    ///
    /// @param  phBufferHandle Free the allocated pool in phBufferHandle
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID ReleaseChiBufferHandlePool(
        CHINODEBUFFERHANDLE* phBufferHandle);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ImageBufferToChiBuffer
    ///
    /// @brief  Convert Camx ImageBuffer to CHINODEBUFFERHANDLE, the CHINODEBUFFERHANDLE will be get from internal pool
    ///
    /// @param  pImageBuffer    The ImageBuffer instance to be converted
    /// @param  phBufferHandle  The pool of ChiBufferHandle to get the CHIBUFFERHANDLE
    /// @param  index           The index of CHINODEBUFFERHANDLE from internal pool
    ///
    /// @return Converted CHINODEBUFFERHANDLE
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CHINODEBUFFERHANDLE ImageBufferToChiBuffer(
        ImageBuffer*         pImageBuffer,
        CHINODEBUFFERHANDLE* phBufferHandle,
        INT32                index);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetChiNodeCapsMask
    ///
    /// @brief  Get ChiNode capabilities mask from NodeProerties
    ///
    /// @param  pCreateInputData  Node create input data
    /// @param  pNodeCreateInfo   Pointer to a structure that defines create session information for the node.
    ///
    /// @return CDKResult
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CDKResult GetChiNodeCapsMask(
        const NodeCreateInputData*  pCreateInputData,
        CHINODECREATEINFO*          pNodeCreateInfo);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CDKResultToCamxResult
    ///
    /// @brief  Convert CDKResult to CamxResult
    ///
    /// @param  result The CDKResult
    ///
    /// @return CamxResult
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CamxResult CDKResultToCamxResult(
        CDKResult result);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CamxResultToCDKResult
    ///
    /// @brief  Convert camxResult to CDKResult
    ///
    /// @param  result The CDKResult
    ///
    /// @return CDKResult
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CDKResult CamxResultToCDKResult(
        CamxResult result);

    struct PerRequestData
    {
        BOOL      isDelayedRequestDone;         ///< Delayed request done
        UINT      numFences;                    ///< Num fences
        CSLFence* phFence[MaxOutputBuffers];    ///< Fences
    };

    PerRequestData       m_perRequestData[MaxRequestQueueDepth];    ///< Per request data
    ChiNodeCallbacks     m_nodeCallbacks;    ///< The callback functions from the CHI node
    CHIHANDLE            m_hNodeSession;     ///< The node session identifier return by creating the CHI node
    UINT                 m_numInputPort;     ///< The number of input port
    CHINODEBUFFERHANDLE* m_phInputBuffer;    ///< The pointer to array of CHIBUFFERHANDLE for input buffer, the size of array
                                             ///  will be determined by m_numInputPort
    UINT                 m_numOutputPort;    ///< The number of output port
    CHINODEBUFFERHANDLE* m_phOutputBuffer;   ///< The pointer to array of CHIBUFFERHANDLE for output buffer, the size of array
                                             ///  will be determined by m_numOutputPort
    CHINODEBYPASSINFO*   m_pBypassData;      ///< Info for bypassable output ports
    const Metadata*      m_pStaticMetadata;  ///< The static metadatapool
    ChiContext*          m_pChiContext;      ///< The pointer to ChiContext
    ChiNodeCapsInfo      m_nodeCapsMask;     ///< Node caps mask
    CHAR*                m_pComponentName;   ///< Component name
    UINT                 m_instancePropertyCapsMask;   ///< GPU Node Instance Property Capabilities mask
    UINT                 m_canNodeSetBufferDependency; ///< Flag to indicate if node can set dependency
};

CAMX_NAMESPACE_END

#endif // CAMXCHINODEWRAPPER_H
